// 导入工具函数，包括判断空值、显示成功提示、克隆对象和消息提示函数
import { TraShenQingDanOutput } from '/@/api/tra/TraShenQing/dto/TraShenQingDanOutput';
import { isNull, showSuccess, clone, msg, showWarning } from '/@/utils';
import { defineEmits, h, ref, reactive, nextTick } from 'vue';
import { ElMessageBox, ElOption, ElSelect } from 'element-plus';
import { PeiFaXueInfoOutput, TraShenQingApi } from '/@/api/tra/TraShenQing';
// 定义 tab 项的类型
interface tabsType {
	// tab名称 血型复核、交叉配血、交叉配血2、临床发血、临床发血2
	name: string
	// tab 类型： 血型复核、交叉配血、临床发血
	type: string
	// key 值：xxfh_单号， jcpx_单号， lcfx_单号
	key: string,
	// 单号， 跟key值分开是因为可能会有相同单号的不同模块
	id: string
}

// 定义返回独立实例状态的函数
export function useTraPeiFaXue(instance: any) {
	// 定义各个组件的引用
	const shenQingDanRef = ref();

	const initCtx = () => ({
		// 标识是否处于编辑状态
		isEdit: false,
		// 标识是否正在加载数据
		loading: false,
		zhuBiao: {} as any,
		shenQingDanInfo: {} as TraShenQingDanOutput,
		// 当前激活的 tab 名称
		tabActiveName: 'dashboard',
		// tab标签初始数组
		tabList: [
			{ name: '血型复核', type: '血型复核', key: 'xxfh_new', id: '' },
			{ name: '交叉配血', type: '交叉配血', key: 'jcpx_new', id: '' },
			{ name: '临床发血', type: '临床发血', key: 'lcfx_new', id: '' },
		] as tabsType[],
		// 配发血信息
		peiFaXueInfo: {} as PeiFaXueInfoOutput,
	});


	// 使用 reactive 初始化响应式上下文对象
	const ctx = reactive(initCtx());
	/**
		 * 获取申请单
		 */
	const getShenQing = async (shenQingDan: any, isNew: boolean = false) => {
		await shenQingDanRef.value.loadShenQingDan(shenQingDan.id);
	};
	/**
 * 获取申请单的回调函数
 * @param billInfo - 申请单信息
 */
	const getShenQingDanCallBack = (billInfo: any) => {
		ctx.shenQingDanInfo = billInfo
		ctx.tabActiveName = 'dashboard'
		// 获取配发血信息
		getPeiFaXue()
	}
	/**
	 * 获取配发血信息
	 */
	const getPeiFaXue = () => {
		if (!ctx.shenQingDanInfo.traShenQing.id) {
			return
		}
		ctx.loading = true
		TraShenQingApi.getPeiFaXueInfo(ctx.shenQingDanInfo.traShenQing.id)
			.then(re => {
				ctx.peiFaXueInfo = re
				ctx.tabList = initCtx().tabList
				updateTabList(re);
			})
			.finally(() => {
				ctx.loading = false
			})
	}
	//#region ================== tab相关处理 =====================
	/**
		 * 根据 API 响应更新 tab 列表
		 * @param response - API 响应数据
		 */
	const updateTabList = (response: PeiFaXueInfoOutput) => {
		if (!isNull(response.fuHe)) {
			const fuHeTab = ctx.tabList.find(t => t.name === '血型复核')
			if (fuHeTab) {
				fuHeTab.key = 'xxfh_' + response.fuHe.id
				fuHeTab.id = response.fuHe.id
			}
		}

		if (response.peiXueList.length > 0) {
			// 过滤掉 tabList 中 type 为交叉配血的项
			ctx.tabList = ctx.tabList.filter(item => item.type !== '交叉配血');
			response.peiXueList.forEach((item, index) => {
				const name = `交叉配血${index === 0 ? '' : index + 1}`
				ctx.tabList.push({ name, type: '交叉配血', key: 'jcpx_' + item.id, id: item.id })
			})
		}

		if (response.faXueList.length > 0) {
			// 过滤掉 tabList 中 type 为临床发血的项
			ctx.tabList = ctx.tabList.filter(item => item.type !== '临床发血');
			response.faXueList.forEach((item, index) => {
				const name = `临床发血${index === 0 ? '' : index + 1}`
				ctx.tabList.push({ name, type: '临床发血', key: 'lcfx_' + item.id, id: item.id })
			})
		}
		const typeOrder = { '血型复核': 1, '交叉配血': 2, '临床发血': 3 };
		ctx.tabList.sort((a, b) => {
			return typeOrder[a.type] - typeOrder[b.type];
		});
	}
	/**
	 * 处理 tab 编辑事件，支持新增 tab 操作
	 * @param targetKey - 目标 tab 的 key 或者鼠标事件对象
	 * @param action - 操作类型，如 'add' 表示新增
	 */
	const onEdit = (targetKey: string | MouseEvent, action: string) => {
		if (action === 'add') {
			// 新增弹框选择的模块
			const selectValue = ref('交叉配血');
			// 弹框选择新增的模块
			const options = ['交叉配血', '临床发血'];
			ElMessageBox({
				title: '选择模块',
				message: () =>
					h(ElSelect, {
						placeholder: '请选择',
						modelValue: selectValue.value, // 绑定组件级响应式变量
						'onUpdate:modelValue': (val: string) => {
							selectValue.value = val
						},
						style: 'width: 150px;'
					}, () => options.map(option =>
						h(ElOption, { value: option, label: option }, () => option)
					)),
				showCancelButton: true,
				confirmButtonText: '确定',
				cancelButtonText: '取消',
				beforeClose: (action, instance, done) => {
					if (action === 'confirm') {
						// 判断是否存在未提交的对应模块，是就不能新建
						if (selectValue.value === '交叉配血' && ctx.tabList.some(t => t.key === 'jcpx_new')) {
							showWarning('存在一个未提交的交叉配血模块，不允许新增相同类型模块');
							return false
						}
						if (selectValue.value === '临床发血' && ctx.tabList.some(t => t.key === 'lcfx_new')) {
							showWarning('存在一个未提交的临床发血模块，不允许新增相同类型模块');
							return false
						}
						done();
					} else {
						done();
					}
				}
			}).then(() => {
				addTabByType(selectValue.value);
			})
		} else {
			//remove(targetKey as string);
		}
	};
	/**
	 * 根据类型添加新的 tab
	 * @param type - 要添加的 tab 类型，如 '交叉配血' 或 '临床发血'
	 */
	const addTabByType = (type: string) => {
		let count, lastIndex;
		switch (type) {
			case '交叉配血':
				count = ctx.tabList.filter(t => t.type === '交叉配血').length
				lastIndex = ctx.tabList.findLastIndex(item => item.type === '交叉配血');
				addTabItem(`交叉配血${count + 1}`, '交叉配血', 'jcpx_new', lastIndex);
				ctx.tabActiveName = 'jcpx_new'
				break;
			case '临床发血':
				count = ctx.tabList.filter(t => t.type === '临床发血').length
				lastIndex = ctx.tabList.findLastIndex(item => item.type === '临床发血');
				addTabItem(`临床发血${count + 1}`, '临床发血', 'lcfx_new', lastIndex);
				ctx.tabActiveName = 'lcfx_new'
				break;
		}
	}
	/**
	 * 向 tab 列表中添加新的 tab 项，添加到同类型的tab后面
	 * @param name - tab 的名称
	 * @param type - tab 的类型
	 * @param key - tab 的 key 值
	 * @param lastIndex - 同类型 tab 的最后一个索引，若为 -1 则添加到末尾
	 */
	const addTabItem = (name: string, type: string, key: string, lastIndex: number) => {
		if (lastIndex === -1) {
			ctx.tabList.push({ name, type, key, id: '' });
		} else {
			ctx.tabList.splice(lastIndex + 1, 0, { name, type, key, id: '' });
		}
	}
	/**
	 * 处理 tab 切换事件
	 * @param tab - 切换到的 tab 的 key
	 */
	const tabChange = (tab: string) => {
		if (tab === 'dashboard') {
			getPeiFaXue()
			return
		}
		const changeTabInfo = ctx.tabList.find(t => t.key === tab)
		if (!changeTabInfo) return
		const { id, key } = changeTabInfo
		if (!id) return

		nextTick(() => {
			const targetRef = instance?.refs[`${key}`]

			if (targetRef) {
				targetRef[0].loadEntity({ id: id })
			}
		})
	}
	/**
	 * 根据类型添加新的 tab 并触发对应模块的新建操作
	 * @param type - 要添加的 tab 类型，如 '血型复核'、'交叉配血' 或 '临床发血'
	 */
	const addTab = (type: string) => {
		switch (type) {
			case '血型复核':
				ctx.tabActiveName = 'xxfh_new'
				nextTick(() => {
					instance?.refs.xxfh_new ? instance?.refs.xxfh_new[0].newEntity() : undefined
				})
				break;
			case '交叉配血':
				if (!ctx.tabList.some(t => t.type === '交叉配血' && !t.id)) {
					addTabByType('交叉配血');
				}
				ctx.tabActiveName = 'jcpx_new'
				nextTick(() => {
					instance?.refs.jcpx_new ? instance?.refs.jcpx_new[0].newEntity() : undefined
				})
				break;
			case '临床发血':
				if (!ctx.tabList.some(t => t.type === '临床发血' && !t.id)) {
					addTabByType('临床发血');
				}
				ctx.tabActiveName = 'lcfx_new'
				nextTick(() => {
					instance?.refs.lcfx_new ? instance?.refs.lcfx_new[0].newEntity() : undefined
				})
				break;
		}
	}
	const gotoTab = (tabName: string) => {
		ctx.tabActiveName = tabName
		nextTick(() => {
			tabChange(tabName)
		})
	}
	/** 单据提交的回调事件，用于更新界面 */
	const submitTabChange = (id: string, type: string) => {
		const nowTabInfo = ctx.tabList.find(t => t.key == ctx.tabActiveName)
		if (!nowTabInfo) return
		nowTabInfo.id = id
		nowTabInfo.key = `${type}_${id}`
		nextTick(() => {
			gotoTab(`${type}_${id}`)
		})
	}
	//#endregion

	return {
		shenQingDanRef,
		ctx,
		onEdit,
		tabChange,
		getShenQing,
		getShenQingDanCallBack,
		addTab,
		gotoTab,
		submitTabChange
	};
};